Python ORM проти Raw SQL: Компроміси продуктивності та коли вибирати

Під час розробки застосунків на Python, які взаємодіють з базами даних, ви стикаєтесь з фундаментальним вибором: використовувати об’єктно-реляційне відображення (ORM) або писати необроблені SQL-запити. Обидва підходи мають свої переваги та недоліки, особливо щодо продуктивності. Ця стаття заглиблюється в компроміси продуктивності між Python ORM і raw SQL, надаючи інформацію, яка допоможе вам приймати обґрунтовані рішення для ваших проєктів.

Що таке ORM і Raw SQL?

Об’єктно-реляційне відображення (ORM)

ORM — це техніка програмування, яка перетворює дані між несумісними системами типів в об’єктно-орієнтованих мовах програмування та реляційних базах даних. По суті, вона надає рівень абстракції, що дозволяє вам взаємодіяти з вашою базою даних, використовуючи об’єкти Python замість написання SQL-запитів безпосередньо. Популярні Python ORM включають SQLAlchemy, Django ORM і Peewee.

Переваги ORM:

• Підвищення продуктивності: ORM спрощують взаємодію з базою даних, зменшуючи обсяг шаблонного коду, який вам потрібно писати.
• Повторне використання коду: ORM дозволяють визначати моделі бази даних як класи Python, сприяючи повторному використанню коду та зручності обслуговування.
• Абстракція бази даних: ORM абстрагують базову базу даних, дозволяючи перемикатися між різними системами баз даних (наприклад, PostgreSQL, MySQL, SQLite) з мінімальними змінами коду.
• Безпека: Багато ORM забезпечують вбудований захист від вразливостей SQL-ін’єкцій.

Raw SQL

Raw SQL передбачає написання SQL-запитів безпосередньо у вашому коді Python для взаємодії з базою даних. Цей підхід дає вам повний контроль над виконуваними запитами та отриманими даними.

Переваги Raw SQL:

• Оптимізація продуктивності: Raw SQL дозволяє точно налаштовувати запити для оптимальної продуктивності, особливо для складних операцій.
• Специфічні для бази даних функції: Ви можете використовувати специфічні для бази даних функції та оптимізації, які можуть не підтримуватися ORM.
• Прямий контроль: Ви маєте повний контроль над згенерованим SQL, що дозволяє точно виконувати запити.

Компроміси продуктивності

Продуктивність ORM і raw SQL може значно відрізнятися залежно від випадку використання. Розуміння цих компромісів має вирішальне значення для створення ефективних програм.

Складність запитів

Прості запити: Для простих операцій CRUD (створення, читання, оновлення, видалення) ORM часто працюють порівняно з raw SQL. Накладні витрати ORM в цих випадках мінімальні.

Складні запити: Зі збільшенням складності запитів raw SQL, як правило, перевершує ORM. ORM можуть генерувати неефективні SQL-запити для складних операцій, що призводить до вузьких місць продуктивності. Наприклад, розглянемо сценарій, коли вам потрібно отримати дані з кількох таблиць зі складною фільтрацією та агрегацією. Погано сконструйований ORM-запит може виконувати кілька кругових переходів до бази даних, отримуючи більше даних, ніж необхідно, тоді як вручну оптимізований raw SQL-запит може виконати те саме завдання з меншою кількістю взаємодій з базою даних.

Взаємодія з базою даних

Кількість запитів: ORM іноді можуть генерувати велику кількість запитів для начебто простих операцій. Це відомо як проблема N+1. Наприклад, якщо ви отримуєте список об’єктів, а потім отримуєте доступ до пов’язаного об’єкта для кожного елемента в списку, ORM може виконати N+1 запитів (один запит для отримання списку та N додаткових запитів для отримання пов’язаних об’єктів). Raw SQL дозволяє записати один запит для отримання всіх необхідних даних, уникаючи проблеми N+1.

Оптимізація запитів: Raw SQL дає вам точний контроль над оптимізацією запитів. Ви можете використовувати специфічні для бази даних функції, як-от індекси, підказки запитів і збережені процедури, щоб покращити продуктивність. ORM не завжди можуть надавати доступ до цих розширених методів оптимізації.

Отримання даних

Гідратація даних: ORM передбачають додатковий крок гідратації отриманих даних в об’єкти Python. Цей процес може збільшити накладні витрати, особливо під час роботи з великими наборами даних. Raw SQL дозволяє отримувати дані в більш легкому форматі, наприклад, у вигляді кортежів або словників, зменшуючи накладні витрати на гідратацію даних.

Кешування

Кешування ORM: Багато ORM пропонують механізми кешування для зменшення навантаження на базу даних. Однак кешування може створити складність і потенційні невідповідності, якщо ним не керувати обережно. Наприклад, SQLAlchemy пропонує різні рівні кешування, які ви налаштовуєте. Якщо кешування налаштовано неправильно, можна повернути застарілі дані.

Кешування Raw SQL: Ви можете реалізувати стратегії кешування з raw SQL, але це вимагає більше ручної роботи. Зазвичай вам потрібно використовувати зовнішній рівень кешування, наприклад Redis або Memcached.

Практичні приклади

Давайте проілюструємо компроміси продуктивності на практичних прикладах з використанням SQLAlchemy і raw SQL.

Приклад 1: Простий запит

ORM (SQLAlchemy):

            
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine('sqlite:///:memory:')
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

# Create some users
user1 = User(name='Alice', age=30)
user2 = User(name='Bob', age=25)
session.add_all([user1, user2])
session.commit()

# Query for a user by name
user = session.query(User).filter_by(name='Alice').first()
print(f"ORM: User found: {user.name}, {user.age}")

            

              
                Copy
              
            
          

Raw SQL:

            
import sqlite3

conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

cursor.execute('''
    CREATE TABLE users (
        id INTEGER PRIMARY KEY,
        name TEXT,
        age INTEGER
    )
''')

# Insert some users
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
conn.commit()

# Query for a user by name
cursor.execute("SELECT name, age FROM users WHERE name = ?", ('Alice',))
user = cursor.fetchone()
print(f"Raw SQL: User found: {user[0]}, {user[1]}")
conn.close()

            

              
                Copy
              
            
          

У цьому простому прикладі різниця в продуктивності між ORM і raw SQL незначна.

Приклад 2: Складний запит

Розглянемо складніший сценарій, коли нам потрібно отримати користувачів та їхні пов’язані замовлення.

ORM (SQLAlchemy):

            
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine('sqlite:///:memory:')
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)
    orders = relationship("Order", back_populates="user")

class Order(Base):
    __tablename__ = 'orders'
    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, ForeignKey('users.id'))
    product = Column(String)
    user = relationship("User", back_populates="orders")

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

# Create some users and orders
user1 = User(name='Alice', age=30)
user2 = User(name='Bob', age=25)
order1 = Order(user=user1, product='Laptop')
order2 = Order(user=user1, product='Mouse')
order3 = Order(user=user2, product='Keyboard')
session.add_all([user1, user2, order1, order2, order3])
session.commit()

# Query for users and their orders
users = session.query(User).all()
for user in users:
    print(f"ORM: User: {user.name}, Orders: {[order.product for order in user.orders]}")

#Demonstrates the N+1 problem.  Without eager loading, a query is executed for each user's orders.

            

              
                Copy
              
            
          

Raw SQL:

            
import sqlite3

conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

cursor.execute('''
    CREATE TABLE users (
        id INTEGER PRIMARY KEY,
        name TEXT,
        age INTEGER
    )
''')

cursor.execute('''
    CREATE TABLE orders (
        id INTEGER PRIMARY KEY,
        user_id INTEGER,
        product TEXT,
        FOREIGN KEY (user_id) REFERENCES users(id)
    )
''')

# Insert some users and orders
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
user_id_alice = cursor.lastrowid # Get Alice's ID
cursor.execute("INSERT INTO orders (user_id, product) VALUES (?, ?)", (user_id_alice, 'Laptop'))
cursor.execute("INSERT INTO orders (user_id, product) VALUES (?, ?)", (user_id_alice, 'Mouse'))

user_id_bob = cursor.execute("SELECT id FROM users WHERE name = 'Bob'").fetchone()[0]
cursor.execute("INSERT INTO orders (user_id, product) VALUES (?, ?)", (user_id_bob, 'Keyboard'))

conn.commit()

# Query for users and their orders using JOIN
cursor.execute("""
    SELECT users.name, orders.product
    FROM users
    LEFT JOIN orders ON users.id = orders.user_id
""")

results = cursor.fetchall()

user_orders = {}
for name, product in results:
    if name not in user_orders:
        user_orders[name] = []
    if product: #Product can be null
      user_orders[name].append(product)

for user, orders in user_orders.items():
    print(f"Raw SQL: User: {user}, Orders: {orders}")

conn.close()

            

              
                Copy
              
            
          

У цьому прикладі raw SQL може бути значно швидшим, особливо якщо ORM генерує кілька запитів або неефективні операції JOIN. Версія raw SQL отримує всі дані в одному запиті за допомогою JOIN, уникаючи проблеми N+1.

Коли вибрати ORM

ORM є хорошим вибором, коли:

• Швидка розробка є пріоритетом. ORM прискорюють процес розробки, спрощуючи взаємодію з базою даних.
• Програма в основному виконує операції CRUD. ORM ефективно обробляють прості операції.
• Абстракція бази даних важлива. ORM дозволяють перемикатися між різними системами баз даних з мінімальними змінами коду.
• Безпека є проблемою. ORM забезпечують вбудований захист від вразливостей SQL-ін’єкцій.
• Команда має обмежений досвід роботи з SQL. ORM абстрагують складності SQL, полегшуючи розробникам роботу з базами даних.

Коли вибрати Raw SQL

Raw SQL є хорошим вибором, коли:

• Продуктивність має вирішальне значення. Raw SQL дозволяє точно налаштовувати запити для оптимальної продуктивності.
• Потрібні складні запити. Raw SQL надає гнучкість для написання складних запитів, які ORM можуть не обробляти ефективно.
• Потрібні функції, специфічні для бази даних. Raw SQL дозволяє використовувати функції та оптимізації, специфічні для бази даних.
• Вам потрібен повний контроль над згенерованим SQL. Raw SQL дає вам повний контроль над виконанням запитів.
• Ви працюєте зі застарілими базами даних або складними схемами. ORM можуть не підходити для всіх застарілих баз даних або схем.

Гібридний підхід

У деяких випадках гібридний підхід може бути найкращим рішенням. Ви можете використовувати ORM для більшості ваших взаємодій з базою даних і вдаватися до raw SQL для певних операцій, які потребують оптимізації або функцій, специфічних для бази даних. Цей підхід дозволяє використовувати переваги як ORM, так і raw SQL.

Бенчмаркінг і профілювання

Найкращий спосіб визначити, чи є ORM або raw SQL більш продуктивним для вашого конкретного випадку використання, — це провести бенчмаркінг і профілювання. Використовуйте такі інструменти, як `timeit` або спеціалізовані інструменти профілювання, щоб виміряти час виконання різних запитів і визначити вузькі місця продуктивності. Розгляньте інструменти, які можуть дати уявлення на рівні бази даних для вивчення планів виконання запитів.

Ось приклад використання `timeit`:

            
import timeit

# Setup code (create database, insert data, etc.) - same setup code from previous examples

# Function using ORM
def orm_query():
  #ORM query
  session = Session()
  user = session.query(User).filter_by(name='Alice').first()
  session.close()
  return user

# Function using Raw SQL
def raw_sql_query():
  #Raw SQL query
  conn = sqlite3.connect(':memory:')
  cursor = conn.cursor()
  cursor.execute("SELECT name, age FROM users WHERE name = ?", ('Alice',))
  user = cursor.fetchone()
  conn.close()
  return user


# Measure execution time for ORM
orm_time = timeit.timeit(orm_query, number=1000)

# Measure execution time for Raw SQL
raw_sql_time = timeit.timeit(raw_sql_query, number=1000)

print(f"ORM Execution Time: {orm_time}")
print(f"Raw SQL Execution Time: {raw_sql_time}")

            

              
                Copy
              
            
          

Запустіть бенчмарки з реалістичними даними та шаблонами запитів, щоб отримати точні результати.

Висновок

Вибір між Python ORM і raw SQL передбачає зважування компромісів продуктивності з продуктивністю розробки, зручністю обслуговування та міркуваннями безпеки. ORM пропонують зручність і абстракцію, тоді як raw SQL забезпечує точний контроль і потенційну оптимізацію продуктивності. Розуміючи сильні та слабкі сторони кожного підходу, ви можете приймати обґрунтовані рішення та створювати ефективні, масштабовані програми. Не бійтеся використовувати гібридний підхід і завжди тестуйте свій код, щоб забезпечити оптимальну продуктивність.

Подальше вивчення

• Документація SQLAlchemy: https://www.sqlalchemy.org/
• Документація Django ORM: https://docs.djangoproject.com/en/4.2/topics/db/models/
• Документація Peewee ORM: http://docs.peewee-orm.com/
• Посібники з налаштування продуктивності бази даних: (Зверніться до документації для вашої конкретної системи бази даних, наприклад, PostgreSQL, MySQL)